const jwt = require("jsonwebtoken");
const utils = require("./utils");
const curl = require("./curl");
const aed = require("./aed");
const constant = require('./constant')
module.exports = {
  ...utils,
  ...curl,
  ...aed,
  constant,
  /**
   * @description 创建token
   * @param {*} data
   */
  async createToken(data) {
    console.log('我创建一个token'+this.config.jwt.secret)
    return jwt.sign(data, this.config.jwt.secret, {
      expiresIn: "24h",
    });
  },

  /**
   * @description 获取 redis缓存
   * @param {String} key 键值名
   */
  async getRedis(key) {
    const res = await this.app.redis.get(key);
    try {
      return JSON.parse(res);
    } catch (err) {
      return res;
    }
  },
  /**
   * @description 设置 redis缓存
   * @param {String} key 键值名
   * @param {Object | String} data 值
   * @param {number} timeout  过期时间，单位 s ，默认 1h
   */
  async setRedis(key, data, timeout = 60 * 60) {
    let formatData;
    if (typeof data === "object") {
      formatData = JSON.stringify(data);
    } else {
      formatData = data;
    }
    console.log('缓存', formatData)
    await this.app.redis.set(key, formatData, "EX", timeout);
  },

  /**
   * @description 删除 redis缓存
   * @param {String} key 键值名
   */
  async delRedis(key) {
    await this.app.redis.del(key);
  },

  // 查询包含时间段的对象组合
  searchTime(params) {
    const searchData = {};
    if (utils.isDef(params.startTime) && utils.isDef(params.endTime)) {
      searchData.createTime = {
        $gte: new Date(params.startTime),
        $lte: new Date(params.endTime),
      };
    }
    return utils.deepCopy(searchData);
  },
  // 将dto转为key-value接口对象的key对象和数组
  /**
   * 函数描述
   * @param {参数类型} dto - 验证规则对象
   * @returns {返回值类型} requiredKeys(返回必须传递的参数的对象集合) paramKeys(返回所有参数的数组集合)
   */
  getRequiredKey(dto) {
    let requiredKeys = {},
      paramKeys = [];
    for (let key in dto) {
      if (dto[key].required) {
        requiredKeys[key] = dto[key].comment;
      }
      paramKeys.push(key);
    }
    return { requiredKeys, paramKeys };
  },
  /**
   * @description 校验必填项
   * @param {*} data 数据对象
   * @param {*} requiredEnum 必填项字典
   */
  checkRequired(data, requiredEnum) {
    for (let key in requiredEnum) {
      if (!this.isDef(data[key])) {
        return `${requiredEnum[key]}必传`;
      }
    }
    return "";
  },
  /**
   * @description 将数据源转化为规定属性对象
   * @param {*} data 数据源
   * @param {*} paramKeyEnum 规定属性
   */
  createParams(data, paramKeyEnum) {
    let params = {};
    paramKeyEnum.map((key) => {
      if (this.isDef(data[key])) {
        params[key] = data[key];
      }
    });
    return this.deepCopy(params);
  },
};
